#include <REGX52.H>

#define MODE_INPUT 0
#define MODE_SET 1

// 密码存储（初始密码为1,2,3,4对应的索引0,1,2,3）
unsigned char password[4] = {0, 1, 2, 3};
unsigned char input[4];     // 当前输入缓存
unsigned char count = 0;    // 当前输入位数
bit mode = MODE_INPUT;      // 当前模式（默认为输入模式）

// 函数声明
void delay_ms(unsigned int ms);
void update_leds();
void error_flash();
bit key_mode_pressed();
bit key_enter_pressed();
bit key_back_pressed();
bit key_digit_pressed(unsigned char index);

void main() {
    unsigned char i, j, duplicate;  // 在函数开头声明所有变量
    
    // 初始化：所有灯灭
    P0 = 0xFF;
    
    while(1) {
        // 1. 检测模式切换键 (P2.4)
        if (key_mode_pressed()) {
            delay_ms(10);
            if (key_mode_pressed()) {
                mode = !mode;  // 切换模式
                count = 0;     // 清空当前输入
                update_leds(); // 更新指示灯
                
                // 设置状态灯控制
                if (mode == MODE_SET) {
                    P0 &= ~(1 << 4); // P0.4亮（设置状态）
                } else {
                    P0 |= (1 << 4);  // P0.4灭（输入状态）
                }
                
                // 等待按键释放
                while(key_mode_pressed());
            }
        }
        
        // 2. 检测返回键 (P2.6)
        if (key_back_pressed()) {
            delay_ms(10);
            if (key_back_pressed()) {
                if (count > 0) {
                    count--;        // 删除最后一位输入
                    update_leds();  // 更新指示灯
                }
                while(key_back_pressed());
            }
        }
        
        // 3. 检测确认键 (P2.5)
        if (key_enter_pressed()) {
            delay_ms(10);
            if (key_enter_pressed()) {
                // 检查输入是否有效（4位且无重复）
                if (count != 4) {
                    error_flash(); // 位数不足
                } else {
                    duplicate = 0;
                    // 检查重复
                    for (i = 0; i < 4; i++) {
                        for (j = i+1; j < 4; j++) {
                            if (input[i] == input[j]) {
                                duplicate = 1;
                                break;
                            }
                        }
                        if (duplicate) break;
                    }
                    
                    if (duplicate) {
                        error_flash(); // 有重复输入
                    } else {
                        if (mode == MODE_INPUT) {
                            // 密码验证模式
                            if (input[0] == password[0] && 
                                input[1] == password[1] && 
                                input[2] == password[2] && 
                                input[3] == password[3]) {
                                // 密码正确：绿灯亮
                                P0 &= ~(1 << 5); // P0.5亮（绿灯）
                                delay_ms(2000);  // 保持2秒
                                P0 |= (1 << 5);  // 绿灯灭
                            } else {
                                error_flash(); // 密码错误
                            }
                        } else {
                            // 密码设置模式：保存新密码
                            password[0] = input[0];
                            password[1] = input[1];
                            password[2] = input[2];
                            password[3] = input[3];
                            
                            // 切回输入模式
                            mode = MODE_INPUT;
                            P0 |= (1 << 4); // 设置状态灯灭
                            
                            // 绿灯闪烁提示成功
                            P0 &= ~(1 << 5); // 绿灯亮
                            delay_ms(200);
                            P0 |= (1 << 5);  // 绿灯灭
                        }
                        // 清空输入
                        count = 0;
                        update_leds();
                    }
                }
                while(key_enter_pressed());
            }
        }
        
        // 4. 检测数字键 (P2.0-P2.3)
        for (i = 0; i < 4; i++) {
            if (key_digit_pressed(i)) {
                delay_ms(10);
                if (key_digit_pressed(i)) {
                    if (count < 4) {
                        // 检查是否重复
                        duplicate = 0;
                        for (j = 0; j < count; j++) {
                            if (input[j] == i) {
                                duplicate = 1;
                                break;
                            }
                        }
                        
                        if (duplicate) {
                            error_flash(); // 重复输入
                        } else {
                            input[count] = i; // 存储输入
                            count++;          // 增加计数
                            update_leds();    // 更新指示灯
                        }
                    }
                    while(key_digit_pressed(i));
                }
            }
        }
    } // while(1)结束
}

// 延时函数
void delay_ms(unsigned int ms) {
    unsigned int i, j;
    for (i = 0; i < ms; i++) {
        for (j = 0; j < 123; j++)
            ;
    }
}

// 更新密码指示灯 (P0.0-P0.3)
void update_leds() {
    // 根据输入位数控制指示灯（低电平点亮）
    P0 = (P0 & 0xF0) | (0x0F & ~((1 << count) - 1));
}

// 错误处理：红灯闪烁
void error_flash() {
    unsigned char i;  // 在函数开头声明变量
    for (i = 0; i < 3; i++) {
        P0 &= ~(1 << 6); // 红灯亮 (P0.6)
        delay_ms(200);
        P0 |= (1 << 6);  // 红灯灭
        delay_ms(200);
    }
    // 清空输入
    count = 0;
    update_leds();
}

// 按键检测函数
bit key_mode_pressed()  { return (P2 & 0x10) == 0; } // P2.4
bit key_enter_pressed() { return (P2 & 0x20) == 0; } // P2.5
bit key_back_pressed()  { return (P2 & 0x40) == 0; } // P2.6

bit key_digit_pressed(unsigned char index) {
    switch(index) {
        case 0: return (P2 & 0x01) == 0; // P2.0
        case 1: return (P2 & 0x02) == 0; // P2.1
        case 2: return (P2 & 0x04) == 0; // P2.2
        case 3: return (P2 & 0x08) == 0; // P2.3
        default: return 0;
    }
}